const express = require('express');
const cors = require('cors');
const jwt = require('jsonwebtoken');
const { auth, JWT_SECRET } = require('./middleware/auth');
const User = require('./models/User');
const Device = require('./models/Device');
const Task = require('./models/Task');
const sequelize = require('./db/connection');

const app = express();

app.use(cors());
app.use(express.json());

// 注册路由
app.post('/api/auth/register', async (req, res) => {
    try {
        const { username, password } = req.body;

        // 检查用户名是否已存在
        const existingUser = await User.findOne({ where: { username } });
        if (existingUser) {
            return res.status(400).json({ message: '用户名已存在' });
        }

        // 创建新用户
        const user = await User.create({ username, password });

        res.status(201).json({ message: '注册成功' });
    } catch (error) {
        console.error('注册错误:', error);
        res.status(500).json({ message: '注册失败，请稍后重试' });
    }
});

// 登录路由
app.post('/api/auth/login', async (req, res) => {
    try {
        const { username, password } = req.body;

        // 查找用户
        const user = await User.findOne({ where: { username } });
        if (!user) {
            return res.status(401).json({ message: '用户名或密码错误' });
        }

        // 验证密码
        const isMatch = await user.comparePassword(password);
        if (!isMatch) {
            return res.status(401).json({ message: '用户名或密码错误' });
        }

        // 生成 JWT
        const token = jwt.sign({ id: user.id }, JWT_SECRET, { expiresIn: '7d' });

        res.json({
            token,
            user: {
                id: user.id,
                username: user.username
            }
        });
    } catch (error) {
        console.error('登录错误:', error);
        res.status(500).json({ message: '登录失败，请稍后重试' });
    }
});

// 获取用户信息
app.get('/api/user/profile', auth, async (req, res) => {
    try {
        const user = await User.findByPk(req.user.id);
        if (!user) {
            return res.status(404).json({ message: '用户不存在' });
        }

        // 获取用户的设备数量
        const deviceCount = await Device.count({
            where: { userId: user.id }
        });

        res.json({
            username: user.username,
            createdAt: user.createdAt,
            deviceCount
        });
    } catch (error) {
        console.error('获取用户信息失败:', error);
        res.status(500).json({ message: '获取用户信息失败' });
    }
});

// 获取设备列表
app.get('/api/devices', auth, async (req, res) => {
    try {
        const devices = await Device.findAll({
            where: { userId: req.user.id },
            order: [['createdAt', 'DESC']]
        });
        res.json(devices);
    } catch (error) {
        console.error('获取设备列表失败:', error);
        res.status(500).json({ message: '获取设备列表失败' });
    }
});

// 添加设备
app.post('/api/devices', auth, async (req, res) => {
    const { name, type, location } = req.body;

    if (!name || !type || !location) {
        return res.status(400).json({ message: '请填写完整的设备信息' });
    }

    try {
        const device = await Device.create({
            userId: req.user.id,
            name,
            type,
            location
        });

        res.status(201).json(device);
    } catch (error) {
        console.error('添加设备失败:', error);
        res.status(500).json({ message: '添加设备失败' });
    }
});

// 删除设备
app.delete('/api/devices/:id', auth, async (req, res) => {
    try {
        const result = await Device.destroy({
            where: {
                id: req.params.id,
                userId: req.user.id
            }
        });

        if (result === 0) {
            return res.status(404).json({ message: '设备不存在' });
        }

        res.json({ message: '设备已删除' });
    } catch (error) {
        console.error('删除设备失败:', error);
        res.status(500).json({ message: '删除设备失败' });
    }
});

// 更新设备状态
app.put('/api/devices/:id/status', auth, async (req, res) => {
    const { status } = req.body;

    if (typeof status !== 'boolean') {
        return res.status(400).json({ message: '状态值无效' });
    }

    try {
        const [updatedCount] = await Device.update(
            { status },
            {
                where: {
                    id: req.params.id,
                    userId: req.user.id
                }
            }
        );

        if (updatedCount === 0) {
            return res.status(404).json({ message: '设备不存在' });
        }

        res.json({ message: '设备状态已更新' });
    } catch (error) {
        console.error('更新设备状态失败:', error);
        res.status(500).json({ message: '更新设备状态失败' });
    }
});

// 获取任务列表
app.get('/api/tasks', auth, async (req, res) => {
    try {
        const tasks = await Task.findAll({
            where: { userId: req.user.id },
            order: [['createdAt', 'DESC']]
        });
        res.json(tasks);
    } catch (error) {
        console.error('获取任务列表失败:', error);
        res.status(500).json({ message: '获取任务列表失败' });
    }
});

// 添加任务
app.post('/api/tasks', auth, async (req, res) => {
    const { name, device, schedule, status } = req.body;

    if (!name || !device || !schedule) {
        return res.status(400).json({ message: '请填写完整的任务信息' });
    }

    try {
        const task = await Task.create({
            userId: req.user.id,
            name,
            device,
            schedule,
            status: status || '待执行'
        });

        res.status(201).json(task);
    } catch (error) {
        console.error('添加任务失败:', error);
        res.status(500).json({ message: '添加任务失败' });
    }
});

// 更新任务
app.put('/api/tasks/:id', auth, async (req, res) => {
    const { name, device, schedule, status } = req.body;

    try {
        const [updatedCount] = await Task.update(
            { name, device, schedule, status },
            {
                where: {
                    id: req.params.id,
                    userId: req.user.id
                }
            }
        );

        if (updatedCount === 0) {
            return res.status(404).json({ message: '任务不存在' });
        }

        const updatedTask = await Task.findOne({
            where: {
                id: req.params.id,
                userId: req.user.id
            }
        });

        res.json(updatedTask);
    } catch (error) {
        console.error('更新任务失败:', error);
        res.status(500).json({ message: '更新任务失败' });
    }
});

// 删除任务
app.delete('/api/tasks/:id', auth, async (req, res) => {
    try {
        const result = await Task.destroy({
            where: {
                id: req.params.id,
                userId: req.user.id
            }
        });

        if (result === 0) {
            return res.status(404).json({ message: '任务不存在' });
        }

        res.json({ message: '任务已删除' });
    } catch (error) {
        console.error('删除任务失败:', error);
        res.status(500).json({ message: '删除任务失败' });
    }
});

// 获取仪表盘统计数据
app.get('/api/dashboard/stats', auth, async (req, res) => {
    try {
        const deviceCount = await Device.count({
            where: { userId: req.user.id }
        });

        const onlineCount = await Device.count({
            where: {
                userId: req.user.id,
                status: true
            }
        });

        const taskCount = await Task.count({
            where: { userId: req.user.id }
        });

        res.json({
            deviceCount,
            onlineCount,
            taskCount
        });
    } catch (error) {
        console.error('获取仪表盘统计数据失败:', error);
        res.status(500).json({ message: '获取统计数据失败' });
    }
});

// 获取最近添加的设备
app.get('/api/dashboard/recent-devices', auth, async (req, res) => {
    try {
        const devices = await Device.findAll({
            where: { userId: req.user.id },
            order: [['createdAt', 'DESC']],
            limit: 5
        });

        res.json(devices);
    } catch (error) {
        console.error('获取最近设备失败:', error);
        res.status(500).json({ message: '获取最近设备失败' });
    }
});

// 初始化数据库并启动服务器
const PORT = process.env.PORT || 3000;

sequelize.sync({ alter: true }).then(() => {
    app.listen(PORT, () => {
        console.log(`服务器运行在 http://localhost:${PORT}`);
    });
}).catch(error => {
    console.error('数据库连接失败:', error);
}); 